Title Banner

Previous Book Contents Book Index Next

Inside Macintosh: QuickTime Components /
Chapter 8 - Video Digitizer Components


Summary of Video Digitizer Components

C Summary

Constants

enum {
   videoDigitizerComponentType = 'vdig',/* standard type for video 
                                           digitizer components */

   /* input format standards */
   ntscIn               = 0,  /* National Television System Committee */
   palIn                = 1,  /* Phase Alternation Line */
   secamIn              = 2,  /* Sequential Color with Memory */

   /* input formats */
   compositeIn       = 0,     /* no color separation of channels */
   sVideoIn          = 1,     /* s-video (super VHS) */
   rgbComponentIn    = 2,     /* separate channels for red, green, & blue */
   /* video digitizer component PlayThru states */
   vdPlayThruOff              = 0,  /* playthrough off */
   vdPlayThruOn               = 1,  /* playthrough on */

   /* field preference options in VDGetFieldPreference function */
   vdUseAnyField  = 0,  /* digitizer component decides which field to use */
   vdUseOddField  = 1,  /* digitizer component uses odd field */
   vdUseEvenField = 2,  /* digitizer component uses even field */

   /* input color space modes */
   vdDigitizerBW  = 0,  /* digitizer component uses black and white */
   vdDigitizerRGB = 1,  /* digitizer component uses red, green, & blue */
   /* phase lock loop modes */
   vdBroadcastMode   = 0,  /* broadcast (laser disk) video mode */
   vdVTRMode         = 1,  /* VCR (magnetic media) mode */
   /* video digitizer component types */
   vdTypeBasic = 0,/* basic component does not support clipping */
   vdTypeAlpha = 1,/* component supports clipping with alpha channel */
   vdTypeMask  = 2,/* component supports clipping with mask plane */
   vdTypeKey   = 3, /* component supports clipping with one or more key
                      colors */
   /* digitizer input capability/current flags */
   digiInDoesNTSC       = (1L<<0),  /* NTSC input */
   digiInDoesPAL        = (1L<<1),  /* PAL input */
   digiInDoesSECAM      = (1L<<2),  /* SECAM format */
   digiInDoesGenLock    = (1L<<7),  /* digitizer performs genlock */
   digiInDoesComposite  = (1L<<8),  /* composite input */
   digiInDoesSVideo     = (1L<<9),  /* s-video input type */
   digiInDoesComponent  = (1L<<10), /* component (RGB) input type */
   digiInVTR_Broadcast  =  (1L<<11),/* differentiates between magnetic
                                       media and broadcast input */
   digiInDoesColor      =  (1L<<12),/* digitizer supports color */
   digiInDoesBW         =  (1L<<13),/* digitizer supports black & white */
   /* digitizer input current flags (these are valid only during active
      operating conditions) */
   digiInSignalLock     = (1L<<31), /* digitizer detects locked input signal 
                                       - this bit = 
                                       horiz lock || vertical lock */
   /* digitizer output capability/current flags */
   digiOutDoes1      =  (1L<<0), /* digitizer supports 1-bit pixels */
   digiOutDoes2      =  (1L<<1), /* digitizer supports 2-bit pixels */
   digiOutDoes4      =  (1L<<2), /* digitizer supports 4-bit pixels */
   digiOutDoes8      =  (1L<<3), /* digitizer supports 8-bit pixels */
   digiOutDoes16     =  (1L<<4), /* digitizer supports 16-bit pixels */
   digiOutDoes32     =  (1L<<5), /* digitizer supports 32-bit pixels */
   digiOutDoesDither =  (1L<<6), /* digitizer dithers in indexed modes */
   digiOutDoesStretch=  (1L<<7), /* digitizer can arbitrarily stretch */
   digiOutDoesShrink =  (1L<<8), /* digitizer can arbitrarily shrink */
   digiOutDoesMask      =  (1L<<9), /* masks to clipping regions */
   digiOutDoesDouble    =  (1L<<11),/* stretches to exactly double size */
   digiOutDoesQuad      =  (1L<<12),/* stretches to exactly quadruple size */
   digiOutDoesQuarter   =  (1L<<13),/* shrinks to exactly one-quarter size */
   digiOutDoesSixteenth =  (1L<<14),/* shrinks to exactly one-sixteenth */
   digiOutDoesRotate    =  (1L<<15),/* supports rotation transformations */
   digiOutDoesHorizFlip =  (1L<<16),/* supports horizontal flips Sx < 0 */
   digiOutDoesVertFlip  =  (1L<<17),/* supports vertical flips Sy < 0 */
   digiOutDoesSkew      =  (1L<<18),/* supports skew (shear,twist) */
   digiOutDoesBlend     =  (1L<<19),/* supports blend operations */
   digiOutDoesWarp      =  (1L<<20),/* supports warp operations */
   digiOutDoesHW_DMA    =  (1L<<21),/* not constrained to local device */
   digiOutDoesHWPlayThru=  (1L<<22),/* doesn't need time to play */
   digiOutDoesILUT      =  (1L<<23),/* does lookup table for index modes */
   digiOutDoesKeyColor  =  (1L<<24),/* performs key color functions too */
   digiOutDoesAsyncGrabs=  (1L<<25),/* supports asynchronous grabs */
   digiOutDoesUnreadableScreenBits
                        =  (1L<<26),/* playthru doesn't generate readable
                                       bits on screen */
   digiOutDoesCompress  =  (1L<<27),/* supports compressed source devices */
   digiOutDoesCompressOnly
                        =  (1L<<28),/* can't draw images */
   digiOutDoesPlayThruDuringCompress 
                        =  (1L<<29) /* can play while providing compressed
                                       data */
};
enum {
   /* video digitizer interface */
   kSelectVDGetMaxSrcRect              = 0x1,/* VDGetMaxSrcRect (required) */
   kSelectVDGetActiveSrcRect           = 0x2,/* VDGetActiveSrcRect 
                                                (required) */
   kSelectVDSetDigitizerRect           = 0x3,/* VDSetDigitizerRect 
                                                (required) */
   kSelectVDGetDigitizerRect           = 0x4,/* VDGetDigitizerRect 
                                                (required) */
   kSelectVDGetVBlankRect              = 0x5,/* VDGetVBlankRect (required) */
   kSelectVDGetMaskPixMap              = 0x6,/* VDGetMaskPixMap */

   /* 1 available selector here */
   kSelectVDGetPlayThruDestination     = 0x8,/* VDGetPlayThruDestination
                                                (required) */
   kSelectVDUseThisCLUT                = 0x9,/* VDUseThisCLUT */
   kSelectVDSetInputGammaValue         = 0xA,/* VDSetInputGammaValue */
   kSelectVDGetInputGammaValue         = 0xB,/* VDGetInputGammaValue */
   kSelectVDSetBrightness              = 0xC,/* VDSetBrightness */
   kSelectVDGetBrightness              = 0xD,/* VDGetBrightness */
   kSelectVDSetContrast                = 0xE,/* VDSetContrast */
   kSelectVDSetHue                     = 0xF,/* VDSetHue */
   kSelectVDSetSharpness               = 0x10,/* VDSetSharpness */
   kSelectVDSetSaturation              = 0x11,/* VDSetSaturation */
   kSelectVDGetContrast                = 0x12,/* VDGetContrast */
   kSelectVDGetHue                     = 0x13,/* VDGetHue */
   kSelectVDGetSharpness               = 0x14,/* VDGetSharpness */
   kSelectVDGetSaturation              = 0x15,/* VDGetSaturation */
   kSelectVDGrabOneFrame               = 0x16,/* VDGrabOneFrame 
                                                (required) */
   kSelectVDGetMaxAuxBuffer            = 0x17,/* VDGetMaxAuxBuffer */
   kSelectVDGetDigitizerInfo           = 0x19,/* VDGetDigitizerInfo 
                                                (required) */
   kSelectVDGetCurrentFlags            = 0x1A,/* VDGetCurrentFlags
                                                (required) */
   kSelectVDSetKeyColor                = 0x1B,/* VDSetKeyColor */
   kSelectVDGetKeyColor                = 0x1C,/* VDGetKeyColor */
   kSelectVDAddKeyColor                = 0x1D,/* VDAddKeyColor */
   kSelectVDGetNextKeyColor            = 0x1E,/* VDGetNextKeyColor */
   kSelectVDSetKeyColorRange           = 0x1F,/* VDSetKeyColorRange */
   kSelectVDGetKeyColorRange           = 0x20,/* VDGetKeyColorRange */
   kSelectVDSetDigitizerUserInterrupt  = 0x21,
                                          /* VDSetDigitizerUserInterrupt */
   kSelectVDSetInputColorSpaceMode     = 0x22,/* VDSetInputColorSpaceMode */
   kSelectVDGetInputColorSpaceMode     = 0x23,/* VDGetInputColorSpaceMode */
   kSelectVDSetClipState               = 0x24,/* VDSetClipState */
   kSelectVDGetClipState               = 0x25,/* VDGetClipState */
   kSelectVDSetClipRgn                 = 0x26,/* VDSetClipRgn */
   kSelectVDClearClipRgn               = 0x27,/* VDClearClipRgn */
   kSelectVDGetCLUTInUse               = 0x28,/* VDGetCLUTInUse */
   kSelectVDSetPLLFilterType           = 0x29,/* VDSetPLLFilterType */
   kSelectVDGetPLLFilterType           = 0x2A,/* VDGetPLLFilterType */
   kSelectVDGetMaskandValue            = 0x2B,/* VDGetMaskandValue */
   kSelectVDSetMasterBlendLevel        = 0x2C,/* VDSetMasterBlendLevel */
   kSelectVDSetPlayThruDestination     = 0x2D,/* VDSetPlayThruDestination */
   kSelectVDSetPlayThruOnOff           = 0x2E,/* VDSetPlayThruOnOff */
   kSelectVDSetFieldPreference         = 0x2F,/* VDSetFieldPreference
                                                (required) */
   kSelectVDGetFieldPreference         = 0x30,/* VDGetFieldPreference
                                                (required) */
   kSelectVDPreflightDestination       = 0x32,/* VDPreflightDestination
                                                (required)  */
   kSelectVDPreflightGlobalRect        = 0x33,/* VDPreflightGlobalRect */
   kSelectVDSetPlayThruGlobalRect      = 0x34,/* VDSetPlayThruGlobalRect */
   kSelectVDSetInputGammaRecord        = 0x35,/* VDSetInputGammaRecord */
   kSelectVDGetInputGammaRecord        = 0x36,/* VDGetInputGammaRecord */
   kSelectVDSetBlackLevelValue         = 0x37,/* VDSetBlackLevelValue */
   kSelectVDGetBlackLevelValue         = 0x38,/* VDGetBlackLevelValue */
   kSelectVDSetWhiteLevelValue         = 0x39,/* VDSetWhiteLevelValue */
   kSelectVDGetWhiteLevelValue         = 0x3A,/* VDGetWhiteLevelValue */
   kSelectVDGetVideoDefaults           = 0x3B,/* VDGetVideoDefaults */
   kSelectVDGetNumberOfInputs          = 0x3C,/* VDGetNumberOfInputs */
   kSelectVDGetInputFormat             = 0x3D,/* VDGetInputFormat */
   kSelectVDSetInput                   = 0x3E,/* VDSetInput */
   kSelectVDGetInput                   = 0x3F,/* VDGetInput */
   kSelectVDSetInputStandard           = 0x40,/* VDSetInputStandard */
   kSelectVDSetupBuffers               = 0x41,/* VDSetupBuffers */
   kSelectVDGrabOneFrameAsync          = 0x42,/* VDGrabOneFrameAsync */
   kSelectVDDone                       = 0x43,/* VDDone */
   kSelectVDSetCompression             = 0x44,/* VDSetCompression */
   kSelectVDCompressOneFrameAsync      = 0x45,/* VDCompressOneFrameAsync */
   kSelectVDCompressDone               = 0x46,/* VDCompressDone */
   kSelectVDReleaseCompressBuffer      = 0x47,/* VDReleaseCompressBuffer */
   kSelectVDGetImageDescription        = 0x48,/* VDGetImageDescription */
   kSelectVDResetCompressSequence      = 0x49,/* VDResetCompressSequence */
   kSelectVDSetCompressionOnOff        = 0x4A,/* VDSetCompressionOnOff */
   kSelectVDGetCompressionTypes        = 0x4B,/* VDGetCompressionTypes */
   kSelectVDSetTimeBase                = 0x4C,/* VDSetTimeBase */
   kSelectVDSetFrameRate               = 0x4D,/* VDSetFrameRate */
   kSelectVDGetDataRate                = 0x4E,/* VDGetDataRate */
   kSelectVDGetSoundInputDriver        = 0x4F,/* VDGetSoundInputDriver */
   kSelectVDGetDMADepths               = 0x50,/* VDGetDMADepths */
   kSelectVDGetPreferredTimeScale      = 0x51,/* VDGetPreferredTimeScale */
   kSelectVDReleaseAsyncBuffers        = 0x52,/* VDReleaseAsyncBuffers */
};
/* flags for VDGetDMADepths depthArray parameter */
enum {
   dmaDepth1      = 1,     /* supports black and white */
   dmaDepth2      = 2,     /* supports 2-bit color */
   dmaDepth4      = 4,     /* supports 4-bit color */
   dmaDepth8      = 8,     /* supports 8-bit color */
   dmaDepth16     = 16,    /* supports 16-bit color */
   dmaDepth32     = 32,    /* supports 32-bit color */
   dmaDepth2Gray  = 64,    /* supports 2-bit grayscale */
   dmaDepth4Gray  = 128,   /* supports 4-bit grayscale */
   dmaDepth8Gray  = 256    /* supports 8-bit grayscale */
};

Data Types

typedef ComponentInstance VideoDigitizerComponent;/* video digitizer
                                                   component */
typedef ComponentResult VideoDigitizerError;    /* video digitizer error */
struct DigitizerInfo {
   short    vdigType;            /* type of digitizer component */
   long     inputCapabilityFlags;/* input video signal features */
   long     outputCapabilityFlags;/* output digitized video data features
                                    of digitizer component */
   long     inputCurrentFlags;   /* status of input video signal */
   long     outputCurrentFlags;  /* status of output digitized video data */
   short    slot;                /* temporary for connection purposes */
   GDHandle gdh;                 /* temporary for digitizers with 
                                    preferred screen */
   GDHandle maskgdh;             /* temporary for digitizers with 
                                    mask planes */
   short    minDestHeight;       /* smallest resizable height */
   short    minDestWidth;        /* smallest resizable width */
   short    maxDestHeight;       /* largest resizable height */
   short    maxDestWidth;        /* largest resizable width */
   short    blendLevels;         /* number of blend levels supported 
                                    (2 if 1 bit mask) */
   long     Private;                /* reserved--set to 0 */
};
typedef struct DigitizerInfo DigitizerInfo;
struct VdigBufferRecList {
   short             count;   /* # of buffers defined by this structure */
   MatrixRecordPtr   matrix;  /* tranformation matrix applied to dest rects
                                 before video image is displayed */
   RgnHandle         mask;    /* clip region applied to dest rect before
                                 video image is displayed */
   VdigBufferRec     list[1]; /* array of output buffer specifications */
};
typedef struct {
   PixMapHandle   dest;    /* handle to pixel map for destination buffer */
   Point          location;/* location of video destination in pixel map */
   long           reserved;/* reserved--set to 0 */
} VdigBufferRec;
typedef struct VDCompressionList {
   CodecComponent    codec;         /* component ID */
   CodecType         cType;         /* compressor type */
   Str63             typeName;      /* compression algorithm */
   Str63             name;          /* compressor name string */
   long              formatFlags;   /* data format flags */
   long              compressFlags; /* capabilities flags */
   long              reserved;      /* set to 0 */
} VDCompressionList, *VDCompressionListPtr, **VDCompressionListHandle;

Video Digitizer Component Functions

Getting Information About Video Digitizer Components

pascal VideoDigitizerError VDGetDigitizerInfo
(VideoDigitizerComponent ci, 
DigitizerInfo *info);
pascal VideoDigitizerError VDGetCurrentFlags
(VideoDigitizerComponent ci, 
long *inputCurrentFlag,
long *outputCurrentFlag);

Setting Source Characteristics

pascal VideoDigitizerError VDGetMaxSrcRect
(VideoDigitizerComponent ci, short inputStd,
Rect *maxSrcRect);
pascal VideoDigitizerError VDGetActiveSrcRect
(VideoDigitizerComponent ci,
short inputStd, Rect *activeSrcRect);
pascal VideoDigitizerError VDGetVBlankRect
(VideoDigitizerComponent ci,
short inputStd, Rect *vBlankRect);
pascal VideoDigitizerError VDSetDigitizerRect
(VideoDigitizerComponent ci, 
Rect *digitizerRect);
pascal VideoDigitizerError VDGetDigitizerRect
(VideoDigitizerComponent ci,
Rect *digitizerRect);

Selecting an Input Source

pascal VideoDigitizerError VDGetNumberOfInputs
(VideoDigitizerComponent ci, short *inputs);
pascal VideoDigitizerError VDSetInput
(VideoDigitizerComponent ci, short input);
pascal VideoDigitizerError VDGetInput
(VideoDigitizerComponent ci, short *input);
pascal VideoDigitizerError VDGetInputFormat
(VideoDigitizerComponent ci, short input,
short *format);
pascal VideoDigitizerError VDSetInputStandard
(VideoDigitizerComponent ci, 
short inputStandard);

Setting Video Destinations

pascal VideoDigitizerError VDSetPlayThruDestination
(VideoDigitizerComponent ci,
PixMapHandle dest, Rect *destRect,
MatrixRecord *m, RgnHandle mask);
pascal VideoDigitizerError VDPreflightDestination
(VideoDigitizerComponent ci, 
Rect *digitizerRect, PixMapHandle dest,
Rect *destRect, MatrixRecord *m);
pascal VideoDigitizerError VDGetPlayThruDestination
(VideoDigitizerComponent ci, 
PixMapHandle *dest, Rect *destRect, MatrixRecord *m, RgnHandle *mask);
pascal VideoDigitizerError VDSetPlayThruGlobalRect
(VideoDigitizerComponent ci, 
GrafPtr theWindow, Rect *globalRect);
pascal VideoDigitizerError VDPreflightGlobalRect
(VideoDigitizerComponent ci,
GrafPtr theWindow, Rect *globalRect);
pascal VideoDigitizerError VDGetMaxAuxBuffer
(VideoDigitizerComponent ci, 
PixMapHandle *pm, Rect *r);

Controlling Compressed Source Devices

pascal VideoDigitizerError VDGetCompressionTypes
(VideoDigitizerComponent ci, VDCompressionListHandle h);
pascal VideoDigitizerError VDSetCompression 
(VideoDigitizerComponent ci, 
OSType compressType, short depth, 
Rect *bounds, CodecQ spatialQuality, 
CodecQ temporalQuality, long keyFrameRate);
pascal VideoDigitizerError VDSetCompressionOnOff 
(VideoDigitizerComponent ci, Boolean state);
pascal VideoDigitizerError VDCompressOneFrameAsync 
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDCompressDone 
(VideoDigitizerComponent ci, Boolean *done, 
Ptr *theData, long *dataSize, 
unsigned char *similarity, TimeRecord *t);
pascal VideoDigitizerError VDReleaseCompressBuffer 
(VideoDigitizerComponent ci, Ptr bufferAddr);
pascal VideoDigitizerError VDGetImageDescription 
(VideoDigitizerComponent ci, ImageDescriptionHandle desc);
pascal VideoDigitizerError VDResetCompressSequence 
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDSetTimeBase 
(VideoDigitizerComponent ci, TimeBase t);

Controlling Digitization

pascal VideoDigitizerError VDSetPlayThruOnOff
(VideoDigitizerComponent ci, short state);
pascal VideoDigitizerError VDGrabOneFrame
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDSetupBuffers
(VideoDigitizerComponent ci,
VdigBufferRecListHandle bufferList);
pascal VideoDigitizerError VDReleaseAsyncBuffers 
(VideoDigitizerComponent ci);
pascal VideoDigitizerError VDGrabOneFrameAsync
(VideoDigitizerComponent ci, short buffer);
pascal long VDDone(VideoDigitizerComponent ci, short buffer);
pascal VideoDigitizerError VDSetFrameRate 
(VideoDigitizerComponent ci, 
Fixed framesPerSecond);
pascal VideoDigitizerError VDGetDataRate 
(VideoDigitizerComponent ci, 
long *milliSecPerFrame, 
Fixed *framesPerSecond, long *bytesPerSecond);

Controlling Color

pascal VideoDigitizerError VDUseThisCLUT
(VideoDigitizerComponent ci, 
CTabHandle colorTableHandle);
pascal VideoDigitizerError VDGetCLUTInUse
(VideoDigitizerComponent ci,
CTabHandle *colorTableHandle);
pascal VideoDigitizerError VDSetInputColorSpaceMode
(VideoDigitizerComponent ci, 
short colorSpaceMode);
pascal VideoDigitizerError VDGetInputColorSpaceMode
(VideoDigitizerComponent ci,
short *colorSpaceMode);
pascal VideoDigitizerError VDGetDMADepths 
(VideoDigitizerComponent ci, 
long *depthArray, long *preferredDepth);

Controlling Analog Video

pascal VideoDigitizerError VDGetVideoDefaults
(VideoDigitizerComponent ci, 
unsigned short *blackLevel, 
unsigned short *whiteLevel,
unsigned short *brightness,
unsigned short *hue,
unsigned short *saturation,
unsigned short *contrast,
unsigned short *sharpness);
pascal VideoDigitizerError VDSetBlackLevelValue
(VideoDigitizerComponent ci, 
unsigned short *blackLevel);
pascal VideoDigitizerError VDGetBlackLevelValue
(VideoDigitizerComponent ci,
unsigned short *blackLevel);
pascal VideoDigitizerError VDSetWhiteLevelValue
(VideoDigitizerComponent ci, 
unsigned short *whiteLevel);
pascal VideoDigitizerError VDGetWhiteLevelValue
(VideoDigitizerComponent ci,
unsigned short *whiteLevel);
pascal VideoDigitizerError VDSetHue
(VideoDigitizerComponent ci,
unsigned short *hue);
pascal VideoDigitizerError VDGetHue
(VideoDigitizerComponent ci,
unsigned short *hue);
pascal VideoDigitizerError VDSetSaturation
(VideoDigitizerComponent ci,
unsigned short *saturation);
pascal VideoDigitizerError VDGetSaturation
(VideoDigitizerComponent ci,
unsigned short *saturation);
pascal VideoDigitizerError VDSetBrightness
(VideoDigitizerComponent ci,
unsigned short *brightness);
pascal VideoDigitizerError VDGetBrightness
(VideoDigitizerComponent ci,
unsigned short *brightness);
pascal VideoDigitizerError VDSetContrast
(VideoDigitizerComponent ci,
unsigned short *contrast);
pascal VideoDigitizerError VDGetContrast
(VideoDigitizerComponent ci,
unsigned short *contrast);
pascal VideoDigitizerError VDSetSharpness
(VideoDigitizerComponent ci,
unsigned short *sharpness);
pascal VideoDigitizerError VDGetSharpness
(VideoDigitizerComponent ci,
unsigned short *sharpness);
pascal VideoDigitizerError VDSetInputGammaRecord
(VideoDigitizerComponent ci, 
VDGamRecPtr inputGammaPtr);
pascal VideoDigitizerError VDGetInputGammaRecord
(VideoDigitizerComponent ci, 
VDGamRecPtr *inputGammaPtr);
pascal VideoDigitizerError VDSetInputGammaValue
(VideoDigitizerComponent ci,
Fixed channel1, Fixed channel2, 
Fixed channel3);
pascal VideoDigitizerError VDGetInputGammaValue
(VideoDigitizerComponent ci,
Fixed *channel1, Fixed *channel2, 
Fixed *channel3);

Selectively Displaying Video

pascal VideoDigitizerError VDSetKeyColor
(VideoDigitizerComponent ci,long index);
pascal VideoDigitizerError VDGetKeyColor
(VideoDigitizerComponent ci, long *index);
pascal VideoDigitizerError VDSetKeyColorRange
(VideoDigitizerComponent ci,
RGBColor *minRGB, RGBColor *maxRGB);
pascal VideoDigitizerError VDAddKeyColor
(VideoDigitizerComponent ci, long *index);
pascal VideoDigitizerError VDGetKeyColorRange 
(VideoDigitizerComponent ci,
RGBColor *minRGB, RGBColor *maxRGB);
pascal VideoDigitizerError VDGetNextKeyColor
(VideoDigitizerComponent ci, long index);
pascal VideoDigitizerError VDSetMasterBlendLevel
(VideoDigitizerComponent ci,
unsigned short *blendLevel);
pascal VideoDigitizerError VDGetMaskandValue
(VideoDigitizerComponent ci,
unsigned short blendLevel, long *mask,
long *value);
pascal VideoDigitizerError VDGetMaskPixMap
(VideoDigitizerComponent ci,
PixMapHandle maskPixMap);

Clipping

pascal VideoDigitizerError VDSetClipRgn
(VideoDigitizerComponent ci,
RgnHandle clipRegion);
pascal VideoDigitizerError VDClearClipRgn
(VideoDigitizerComponent ci,
RgnHandle clipRegion);
pascal VideoDigitizerError VDSetClipState
(VideoDigitizerComponent ci, short clipEnable);
pascal VideoDigitizerError VDGetClipState
(VideoDigitizerComponent ci, short *clipEnable);

Utility Functions

pascal VideoDigitizerError VDSetPLLFilterType
(VideoDigitizerComponent ci, short pllType);
pascal VideoDigitizerError VDGetPLLFilterType
(VideoDigitizerComponent ci, short *pllType);
pascal VideoDigitizerError VDSetFieldPreference
(VideoDigitizerComponent ci, short fieldFlag);
pascal VideoDigitizerError VDGetFieldPreference
(VideoDigitizerComponent ci, short *fieldFlag);
pascal VideoDigitizerError VDSetDigitizerUserInterrupt
(VideoDigitizerComponent ci, long flags, VdigIntProc userInterruptProc, long refcon);
pascal VideoDigitizerError VDGetSoundInputDriver 
(VideoDigitizerComponent ci, 
Str255 soundDriverName);
pascal VideoDigitizerError VDGetPreferredTimeScale 
(VideoDigitizerComponent ci, 
TimeScale *preferred);

Application-Defined Function

pascal void MyInterruptProc (long flags, long refcon);

Pascal Summary

Constants

CONST
   videoDigitizerComponentType = 'vdig';  {standard type for video }
                                          { digitizer components}
   
   {input format standards}
   ntscIn            = 0;  {National Television System Committee}
   palIn             = 1;  {Phase Alternation Line}
   secamIn           = 2;  {Sequential Color with Memory} 
   
   {input formats}
   compositeIn       = 0;  {no color separation of channels}
   sVideoIn          = 1;  {s-video (Super VHS)}
   rgbComponentIn    = 2;  {separate channels for red, green, & blue}
   
   {video digitizer PlayThru states}
   vdPlayThruOff     = 0;  {playthrough off}
   vdPlayThruOn      = 1;  {playthrough on}
   
   {field preference options in VDGetFieldPreference function}
   vdUseAnyField     = 0;  {digitizer component decides which field to use}
   vdUseOddField     = 1;  {digitizer component uses odd field}
   vdUseEvenField    = 2;  {digitizer component uses even field}

   {input color space modes}
   vdDigitizerBW     = 0;  {digitizer component uses black and white}
   vdDigitizerRGB    = 1;  {digitizer component uses red, green, and blue}

   {phase lock loop modes}
   vdBroadcastMode   = 0;  {broadcast or laser disk video mode}
   vdVTRMode         = 1;  {video cassette recorder or magnetic media mode}

   {video digitizer component types}
   vdTypeBasic       = 0;  {basic component does not support clipping}
   vdTypeAlpha       = 1;  {component supports clipping with alpha channel}
   vdTypeMask        = 2;  {component supports clipping with mask plane}
   vdTypeKey         = 3;  {supports clipping with one or more key colors}
   
   {digitizer input capability/current flags}
   digiInDoesNTSC       = $1;    {digitizer supports NTSC input}
   digiInDoesPAL        = $2;    {digitizer supports PAL input}
   digiInDoesSECAM      = $4;    {digitizer supports SECAM input}
   digiInDoesGenLock    = $80;   {digitizer supports genlock}
   digiInDoesComposite  = $100;  {digitizer supports composite input type}
   digiInDoesSVideo     = $200;  {digitizer supports s-video input type}
   digiInDoesComponent  = $400;  {digitizer supports component input type}
   digiInVTR_Broadcast  = $800;  {digitizer can differentiate between }
                                 { magnetic media & broadcast}
   digiInDoesColor      = $1000; {digitizer supports color}
   digiInDoesBW         = $2000; {digitizer supports black and white}
   
   {digitizer input current flag (valid only during active operating }
   { conditions)}
   digiInSignalLock     = $80000000;{digitizer detects input signal is }
                                    { locked--this bit equals }
                                    { horiz lock || vertical lock}
   {digitizer output capability/current flags}
   digiOutDoes1         = $1;          {digitizer supports 1-bit pixels}
   digiOutDoes2         = $2;          {digitizer supports 2-bit pixels}
   digiOutDoes4         = $4;          {digitizer supports 4-bit pixels}
   digiOutDoes8         = $8;          {digitizer supports 8-bit pixels}
   digiOutDoes16        = $10;         {digitizer supports 16-bit pixels}
   digiOutDoes32        = $20;         {digitizer supports 32-bit pixels}
   digiOutDoesDither    = $40;         {digitizer dithers in indexed modes}
   digiOutDoesStretch   = $80;         {digitizer can arbitrarily stretch}
   digiOutDoesShrink    = $100;        {digitizer can arbitrarily shrink}
   digiOutDoesMask      = $200;        {digitizer can mask to clipping }
                                       { regions}
   digiOutDoesDouble    = $800;        {can stretch to exactly double size}
   digiOutDoesQuad      = $1000;       {can stretch to exactly quadruple }
                                       { size}
   digiOutDoesQuarter   = $2000;       {can shrink to exactly 1/4 size}
   digiOutDoesSixteenth = $4000;       {can shrink to exactly 1/16 size}
   digiOutDoesRotate    = $8000;       {supports rotation transformations}
   digiOutDoesHorizFlip = $10000;      {supports horizontal flips Sx < 0}
   digiOutDoesVertFlip  = $20000;      {supports vertical flips Sy < 0}
   digiOutDoesSkew      = $40000;      {supports skew (shear, twist)} 
   digiOutDoesBlend     = $80000;      {digitizer performs blend operations}
   digiOutDoesWarp      = $100000;     {digitizer performs warp operations}
   digiOutDoesHW_DMA    = $200000;     {not constrained to logical device}
   digiOutDoesHWPlayThru= $400000;     {doesn't need time to play through}
   digiOutDoesILUT      = $800000;     {does lookup for index modes}
   digiOutDoesKeyColor  = $1000000;    {performs key color functions too}
   digiOutDoesAsyncGrabs= $2000000;    {performs asynchronous grabs}
   digiOutDoesUnreadableScreenBits  
                        = $4000000;    {playthru doesn't generate readable }
                                       { bits on screen}
   digiOutDoesCompress  = $8000000;    {supports compressed source devices}
   digiOutDoesCompressOnly 
                        =  $10000000;  {can't draw images}
   digiOutDoesPlayThruDuringCompress 
                        = $2000000;    {can play while providing compressed }
                                       { data}
   {video digitizer interface}
   kSelectVDGetMaxSrcRect           = $1; {VDGetMaxSrcRect (required)}
   kSelectVDGetActiveSrcRect        = $2; {VDGetActiveSrcRect (required)}
   kSelectVDSetDigitizerRect        = $3; {VDSetDigitizerRect (required)}
   kSelectVDGetDigitizerRect        = $4; {VDGetDigitizerRect (required)}
   kSelectVDGetVBlankRect           = $5; {VDGetVBlankRect (required)}
   kSelectVDGetMaskPixMap           = $6; {VDGetMaskPixMap}
   kSelectVDGetPlayThruDestination  = $8; {VDGetPlayThruDestination }
                                          { (required)}
   kSelectVDUseThisCLUT             = $9; {VDUseThisCLUT}
   kSelectVDSetInputGammaValue      = $A; {VDSetInputGammaValue}
   kSelectVDGetInputGammaValue      = $B; {VDGetInputGammaValue}
   kSelectVDSetBrightness           = $C; {VDSetBrightness}
   kSelectVDGetBrightness           = $D; {VDGetBrightness}
   kSelectVDSetContrast             = $E; {VDSetContrast}
   kSelectVDSetHue                  = $F; {VDSetHue}
   kSelectVDSetSharpness            = $10;{VDSetSharpness}
   kSelectVDSetSaturation           = $11;{VDSetSaturation}
   kSelectVDGetContrast             = $12;{VDGetContrast}
   kSelectVDGetHue                  = $13;{VDGetHue}
   kSelectVDGetSharpness            = $14;{VDGetSharpness}
   kSelectVDGetSaturation           = $15;{VDGetSaturation}
   kSelectVDGrabOneFrame            = $16;{VDGrabOneFrame (required)}
   kSelectVDGetMaxAuxBuffer         = $17;{VDGetMaxAuxBuffer}
   kSelectVDGetDigitizerInfo        = $19;{VDGetDigitizerInfo}
   kSelectVDGetCurrentFlags         = $1A;{VDGetCurrentFlags}
   kSelectVDSetKeyColor             = $1B;{VDSetKeyColor}
   kSelectVDGetKeyColor             = $1C;{VDGetKeyColor}
   kSelectVDAddKeyColor             = $1D;{VDAddKeyColor}
   kSelectVDGetNextKeyColor         = $1E;{VDGetNextKeyColor}
   kSelectVDSetKeyColorRange        = $1F;{VDSetKeyColorRange}
   kSelectVDGetKeyColorRange        = $20;{VDGetKeyColorRange}
   kSelectVDSetDigitizerUserInterrupt  
                                    = $21;{VDSetDigitizerUserInterrupt}
   kSelectVDSetInputColorSpaceMode  = $22;{VDSetInputColorSpaceMode}
   kSelectVDGetInputColorSpaceMode  = $23;{VDGetInputColorSpaceMode}
   kSelectVDSetClipState            = $24;{VDSetClipState}
   kSelectVDGetClipState            = $25;{VDGetClipState}
   kSelectVDSetClipRgn              = $26;{VDSetClipRgn}
   kSelectVDClearClipRgn            = $27;{VDClearClipRgn}
   kSelectVDGetCLUTInUse            = $28;{VDGetCLUTInUse}
   kSelectVDSetPLLFilterType        = $29;{VDSetPLLFilterType}
   kSelectVDGetPLLFilterType        = $2A;{VDGetPLLFilterType}
   kSelectVDGetMaskandValue         = $2B;{VDGetMaskandValue}
   kSelectVDSetMasterBlendLevel     = $2C;{VDSetMasterBlendLevel}
   kSelectVDSetPlayThruDestination  = $2D;{VDSetPlayThruDestination}
   kSelectVDSetPlayThruOnOff        = $2E;{VDSetPlayThruOnOff}
   kSelectVDSetFieldPreference      = $2F;{VDSetFieldPreference }
                                          { (required)}
   kSelectVDGetFieldPreference      = $30;{VDGetFieldPreference }
                                          { (required)}
   kSelectVDPreflightDestination    = $32;{VDPreflightDestination }
                                          { (required)}
   kSelectVDPreflightGlobalRect     = $33;{VDPreflightGlobalRect}
   kSelectVDSetPlayThruGlobalRect   = $34;{VDSetPlayThruGlobalRect}
   kSelectVDSetInputGammaRecord     = $35;{VDSetInputGammaRecord}
   kSelectVDGetInputGammaRecord     = $36;{VDGetInputGammaRecord}
   kSelectVDSetBlackLevelValue      = $37;{VDSetBlackLevelValue}
   kSelectVDGetBlackLevelValue      = $38;{VDGetBlackLevelValue}
   kSelectVDSetWhiteLevelValue      = $39;{VDSetWhiteLevelValue}
   kSelectVDGetWhiteLevelValue      = $3A;{VDGetWhiteLevelValue}
   kSelectVDGetVideoDefaults        = $3B;{VDGetVideoDefaults}
   kSelectVDGetNumberOfInputs       = $3C;{VDGetNumberOfInputs}
   kSelectVDGetInputFormat          = $3D;{VDGetInputFormat}
   kSelectVDSetInput                = $3E;{VDSetInput}
   kSelectVDGetInput                = $3F;{VDGetInput}
   kSelectVDSetInputStandard        = $40;{VDSetInputStandard}
   kSelectVDSetupBuffers            = $41;{VDSetupBuffers}
   kSelectVDGrabOneFrameAsync       = $42;{VDGrabOneFrameAsync}
   kSelectVDDone                    = $43;{VDDone}
   kSelectVDSetCompression          = $44;{VDSetCompression}
   kSelectVDCompressOneFrameAsync   = $45;{VDCompressOneFrameAsync}
   kSelectVDCompressDone            = $46;{VDCompressDone}
   kSelectVDReleaseCompressBuffer   = $47;{VDReleaseCompressBuffer}
   kSelectVDGetImageDescription     = $48;{VDGetImageDescription}
   kSelectVDResetCompressSequence   = $49;{VDResetCompressSequence}
   kSelectVDSetCompressionOnOff     = $4A;{VDSetCompressionOnOff}
   kSelectVDGetCompressionTypes     = $4B;{VDGetCompressionTypes}
   kSelectVDSetTimeBase             = $4C;{VDSetTimeBase}
   kSelectVDSetFrameRate            = $4D;{VDSetFrameRate}
   kSelectVDGetDataRate             = $4E;{VDGetDataRate}
   kSelectVDGetSoundInputDriver     = $4F;{VDGetSoundInputDriver}
   kSelectVDGetDMADepths            = $50;{VDGetDMADepths}
   kSelectVDGetPreferredTimeScale   = $51;{VDGetPreferredTimeScale}
   kSelectVDReleaseAsyncBuffers     = $52;{VDReleaseAsyncBuffers}

Data Types

TYPE
   VideoDigitizerComponent          = ComponentInstance; {video digitizer }
                                                         { component}
   VideoDigitizerError              = ComponentResult;   {video digitizer }
                                                         { error}
   VdigIntProc                      = ComponentResult; 
   DigitizerInfo =
   RECORD
      vdigType:               Integer; {type of digitizer component}
      inputCapabilityFlags:   LongInt; {input video signal features}
      outputCapabilityFlags:  LongInt; {output digitized video data features}
      inputCurrentFlags:      LongInt; {status of input video signal}
      outputCurrentFlags:     LongInt; {status of output digitized data}
      slot:                   Integer; {temporary for connection purposes} 
      gdh:                    GDHandle;{temporary for digitizers with }
                                       { preferred screen} 
      maskgdh:                GDHandle;{temporary for digitizers }
                                       { with mask planes}
      minDestHeight:          Integer; {smallest resizable height}
      minDestWidth:           Integer; {smallest resizable width}
      maxDestHeight:          Integer; {largest resizable height}
      maxDestWidth:           Integer; {largest resizable width}
      blendLevels:            Integer; {number of blend levels supported (2 }
                                       { if 1 bit mask)} 
      Private:                LongInt; {reserved--set to 0}
   END;
   VdigBufferRec =
   RECORD 
      dest:       PixMapHandle;  {handle to pixel map for destination buffer}
      location:   Point;         {location of video destination in pixel map}
      reserved:   LongInt;       {reserved--set to 0}
   END; 

   VdigBufferRecListPtr          = ^VdigBufferRecList; 
   VdigBufferRecListHandle       = ^VdigBufferRecListPtr; 
   VdigBufferRecList = 
   RECORD 
      count:            Integer;          {buffers defined by this record}
      matrix:           MatrixRecordPtr ; {transformation matrix applied to }
                                          { dest rect before image displayed}
      mask:             RgnHandle;        {clip rgn applied to dest rect }
                                          { before image displayed}
      list:             ARRAY[0..0] OF VdigBufferRec; 
                                          {array of output buffer specs}
   END; 
VDCompressionListHandle = ^VDCompressionListPtr;
VDCompressionList = 
   RECORD
      codec:            CodecComponent;   {component ID}
      cType:            CodecType;        {compressor type}
      typeName:         Str63;            {compression algorithm}
      name:             Str63;            {compressor name string}
      formatFlags:      LongInt;          {data format flags}
      compressFlags:    LongInt;          {capabilities flags}
      reserved:         LongInt;          {set to 0}
   END; 

Video Digitizer Component Routines

Getting Information About Video Digitizer Components

FUNCTION VDGetDigitizerInfo 
(ci: VideoDigitizerComponent; 
VAR info: DigitizerInfo): VideoDigitizerError;
FUNCTION VDGetCurrentFlags (ci: VideoDigitizerComponent; 
VAR inputCurrentFlag: LongInt; 
VAR outputCurrentFlag: LongInt): 
VideoDigitizerError;

Setting Source Characteristics

FUNCTION VDGetMaxSrcRect (ci: VideoDigitizerComponent; 
VAR maxSrcRect: Rect): VideoDigitizerError;
FUNCTION VDGetActiveSrcRect 
(ci: VideoDigitizerComponent; inputStd: Integer;
VAR activeSrcRect: Rect): VideoDigitizerError;
FUNCTION VDGetVBlankRect (ci: VideoDigitizerComponent; 
VAR vBlankRect: Rect): VideoDigitizerError;
FUNCTION VDSetDigitizerRect 
(ci: VideoDigitizerComponent; 
VAR digitizerRect: Rect): VideoDigitizerError;
FUNCTION VDGetDigitizerRect 
(ci: VideoDigitizerComponent; 
VAR digitizerRect: Rect): VideoDigitizerError;

Selecting an Input Source

FUNCTION VDGetNumberOfInputs
(ci: VideoDigitizerComponent; 
VAR inputs: Integer): VideoDigitizerError;
FUNCTION VDSetInput (ci: VideoDigitizerComponent; 
input: Integer): VideoDigitizerError;
FUNCTION VDGetInput (ci: VideoDigitizerComponent; 
VAR input: Integer): VideoDigitizerError;
FUNCTION VDGetInputFormat (ci: VideoDigitizerComponent; input: Integer; 
VAR format: Integer): VideoDigitizerError;
FUNCTION VDSetInputStandard 
(ci: VideoDigitizerComponent; 
inputStandard: Integer): VideoDigitizerError;

Setting Video Destinations

FUNCTION VDSetPlayThruDestination 
(ci: VideoDigitizerComponent; 
dest: PixMapHandle; VAR destRect: Rect; 
VAR m: MatrixRecord; 
mask: RgnHandle): VideoDigitizerError;
FUNCTION VDPreflightDestination 
(ci: VideoDigitizerComponent; 
VAR digitizerRect: Rect; dest: PixMapHandle; VAR destRect: Rect; 
VAR m: MatrixRecord): VideoDigitizerError;
FUNCTION VDGetPlayThruDestination 
(ci: VideoDigitizerComponent; 
VAR dest: PixMapHandle; VAR destRect: Rect; VAR m: MatrixRecord; 
VAR mask: RgnHandle): VideoDigitizerError;
FUNCTION VDSetPlayThruGlobalRect
(ci: VideoDigitizerComponent; 
theWindow: GrafPtr; VAR globalRect: Rect): VideoDigitizerError;
FUNCTION VDPreflightGlobalRect
(ci: VideoDigitizerComponent; 
theWindow: GrafPtr; VAR globalRect: Rect): VideoDigitizerError;
FUNCTION VDGetMaxAuxBuffer (ci: VideoDigitizerComponent; 
VAR pm: PixMapHandle; VAR r: Rect): 
VideoDigitizerError;

Controlling Compressed Source Devices

FUNCTION VDGetCompressionTypes
(ci: VideoDigitizerComponent; 
h: VDCompressionListHandle): VideoDigitizerError;
FUNCTION VDSetCompression(ci: VideoDigitizerComponent; 
compressType: OSType; depth: Integer; 
VAR bounds: Rect; spatialQuality: CodecQ; 
temporalQuality: CodecQ; 
keyFrameRate: LongInt): VideoDigitizerError;
FUNCTION VDSetCompressionOnOff
(ci: VideoDigitizerComponent; state: Boolean): VideoDigitizerError;
FUNCTION VDGrabOneFrameAsync
(ci: VideoDigitizerComponent; buffer: Integer): VideoDigitizerError;
FUNCTION VDCompressDone(ci: VideoDigitizerComponent; 
VAR done: Boolean; VAR theData: Ptr; 
VAR dataSize: LongInt; VAR similarity: Byte; 
VAR t: TimeRecord): VideoDigitizerError;
FUNCTION VDReleaseCompressBuffer
(ci: VideoDigitizerComponent; 
bufferAddr: Ptr): VideoDigitizerError;
FUNCTION VDGetImageDescription
(ci: VideoDigitizerComponent; 
desc: ImageDescriptionHandle): VideoDigitizerError;
FUNCTION VDResetCompressSequence
(ci: VideoDigitizerComponent): VideoDigitizerError;
FUNCTION VDSetTimeBase(ci: VideoDigitizerComponent; t: TimeBase): 
VideoDigitizerError; 

Controlling Digitization

FUNCTION VDSetPlayThruOnOff (ci: VideoDigitizerComponent; 
state: Integer): VideoDigitizerError;
FUNCTION VDGrabOneFrame (ci: VideoDigitizerComponent): 
VideoDigitizerError;
FUNCTION VDSetupBuffers (ci: VideoDigitizerComponent; 
bufferList: VdigBufferRecListHandle): 
VideoDigitizerError;
FUNCTION VDReleaseAsyncBuffers 
(ci: VideoDigitizerComponent): VideoDigitizerError;
FUNCTION VDGrabOneFrameAsync
(ci: VideoDigitizerComponent; 
nextBuffer: Integer): VideoDigitizerError;
FUNCTION VDDone (ci: VideoDigitizerComponent, 
buffer: Integer): LongInt;
FUNCTION VDSetFrameRate(ci: VideoDigitizerComponent; 
framesPerSecond: Fixed): VideoDigitizerError; 
FUNCTION VDGetDataRate(ci: VideoDigitizerComponent; 
VAR milliSecPerFrame: LongInt; 
VAR framesPerSecond: Fixed; 
VAR bytesPerSecond: LongInt): 
VideoDigitizerError;

Controlling Color

FUNCTION VDUseThisCLUT (ci: VideoDigitizerComponent; 
colorTableHandle: CTabHandle): 
VideoDigitizerError;
FUNCTION VDGetCLUTInUse (ci: VideoDigitizerComponent; 
VAR colorTableHandle: CTabHandle): 
VideoDigitizerError;
FUNCTION VDSetInputColorSpaceMode 
(ci: VideoDigitizerComponent; 
colorSpaceMode: Integer): VideoDigitizerError;
FUNCTION VDGetInputColorSpaceMode 
(ci: VideoDigitizerComponent; 
VAR colorSpaceMode: Integer): VideoDigitizerError;
FUNCTION VDGetDMADepths(ci: VideoDigitizerComponent; 
VAR depthArray: LongInt; VAR preferredDepth: 
LongInt): VideoDigitizerError;

Controlling Analog Video

FUNCTION VDGetVideoDefaults (ci: VideoDigitizerComponent; 
VAR blackLevel: Integer; 
VAR whiteLevel: Integer; 
VAR brightness: Integer; VAR hue: Integer; 
VAR saturation: Integer; VAR contrast: Integer; 
VAR sharpness: Integer): VideoDigitizerError;
FUNCTION VDSetBlackLevelValue
(ci: VideoDigitizerComponent; 
VAR blackLevel: Integer): VideoDigitizerError;
FUNCTION VDGetBlackLevelValue
(ci: VideoDigitizerComponent; 
VAR blackLevel: Integer): VideoDigitizerError;
FUNCTION VDSetWhiteLevelValue
(ci: VideoDigitizerComponent; 
VAR whiteLevel: Integer): VideoDigitizerError;
FUNCTION VDGetWhiteLevelValue
(ci: VideoDigitizerComponent; 
VAR whiteLevel: Integer): VideoDigitizerError;
FUNCTION VDSetHue (ci: VideoDigitizerComponent; 
VAR hue: Integer): VideoDigitizerError;
FUNCTION VDGetHue (ci: VideoDigitizerComponent; 
VAR hue: Integer): VideoDigitizerError;
FUNCTION VDSetSaturation (ci: VideoDigitizerComponent; 
VAR saturation: Integer): VideoDigitizerError;
FUNCTION VDGetSaturation (ci: VideoDigitizerComponent; 
VAR saturation: Integer): VideoDigitizerError;
FUNCTION VDSetBrightness (ci: VideoDigitizerComponent; 
VAR brightness: Integer): VideoDigitizerError;
FUNCTION VDGetBrightness (ci: VideoDigitizerComponent; 
VAR brightness: Integer): VideoDigitizerError;
FUNCTION VDSetContrast (ci: VideoDigitizerComponent; 
VAR contrast: Integer): VideoDigitizerError;
FUNCTION VDGetContrast (ci: VideoDigitizerComponent; 
VAR contrast: Integer): VideoDigitizerError;
FUNCTION VDSetSharpness (ci: VideoDigitizerComponent; 
VAR sharpness: Integer): VideoDigitizerError;
FUNCTION VDGetSharpness (ci: VideoDigitizerComponent; 
VAR sharpness: Integer): VideoDigitizerError;
FUNCTION VDSetInputGammaRecord 
(ci: VideoDigitizerComponent; 
inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
FUNCTION VDGetInputGammaRecord 
(ci: VideoDigitizerComponent; 
VAR inputGammaPtr: VDGamRecPtr): VideoDigitizerError;
FUNCTION VDSetInputGammaValue 
(ci: VideoDigitizerComponent; channel1: Fixed; channel2: Fixed; channel3: Fixed): VideoDigitizerError;
FUNCTION VDGetInputGammaValue 
(ci: VideoDigitizerComponent; 
VAR channel1: Fixed; VAR channel2: Fixed; 
VAR channel3: Fixed): VideoDigitizerError;

Selectively Displaying Video

FUNCTION VDSetKeyColor (ci: VideoDigitizerComponent; 
index: LongInt): VideoDigitizerError;
FUNCTION VDGetKeyColor (ci: VideoDigitizerComponent; 
VAR index: LongInt): VideoDigitizerError;
FUNCTION VDSetKeyColorRange 
(ci: VideoDigitizerComponent; 
VAR minRGB: RGBColor; VAR maxRGB: RGBColor): VideoDigitizerError;
FUNCTION VDAddKeyColor (ci: VideoDigitizerComponent; 
VAR index: LongInt): VideoDigitizerError;
FUNCTION VDGetKeyColorRange 
(ci: VideoDigitizerComponent; 
VAR minRGB: RGBColor; VAR maxRGB: RGBColor): VideoDigitizerError;
FUNCTION VDGetNextKeyColor (ci: VideoDigitizerComponent; 
index: LongInt): VideoDigitizerError;
FUNCTION VDSetMasterBlendLevel 
(ci: VideoDigitizerComponent; 
VAR blendLevel: Integer): VideoDigitizerError;
FUNCTION VDGetMaskandValue (ci: VideoDigitizerComponent; 
blendLevel: Integer; VAR mask: LongInt; 
VAR value: LongInt): VideoDigitizerError;
FUNCTION VDGetMaskPixMap (ci: VideoDigitizerComponent; 
maskPixMap: PixMapHandle): VideoDigitizerError;

Clipping

FUNCTION VDSetClipRgn (ci: VideoDigitizerComponent; 
clipRegion: RgnHandle): VideoDigitizerError;
FUNCTION VDClearClipRgn (ci: VideoDigitizerComponent; 
clipRegion: RgnHandle): VideoDigitizerError;
FUNCTION VDSetClipState (ci: VideoDigitizerComponent; 
clipEnable: Integer): VideoDigitizerError;
FUNCTION VDGetClipState (ci: VideoDigitizerComponent; 
VAR clipEnable: Integer): VideoDigitizerError;

Utility Functions

FUNCTION VDSetPLLFilterType 
(ci: VideoDigitizerComponent; 
pllType: Integer): VideoDigitizerError;
FUNCTION VDGetPLLFilterType 
(ci: VideoDigitizerComponent; 
VAR pllType: Integer): VideoDigitizerError;
FUNCTION VDSetFieldPreference
(ci: VideoDigitizerComponent; 
fieldFlag: Integer): VideoDigitizerError;
FUNCTION VDGetFieldPreference 
(ci: VideoDigitizerComponent; 
VAR fieldFlag: Integer): VideoDigitizerError;
FUNCTION VDSetDigitizerUserInterrupt 
(ci: VideoDigitizerComponent; 
flags: LongInt; userInterruptProc: ProcPtr; 
refcon: LongInt): VideoDigitizerError;
FUNCTION VDGetSoundInputDriver
(ci: VideoDigitizerComponent; 
soundDriverName: Str255): VideoDigitizerError;
FUNCTION VDGetPreferredTimeScale
(ci: VideoDigitizerComponent; 
preferred: TimeScale): VideoDigitizerError;

Application-Defined Routine

PROCEDURE MyInterruptProc (flags: LongInt; refcon: LongInt);

Result Codes


Previous Book Contents Book Index Next

© Apple Computer, Inc.
7 JUL 1996




Navigation graphic, see text links

Main | Top of Section | What's New | Apple Computer, Inc. | Find It | Feedback | Help